'use strict'

const Koa = require('koa');
const router = require('koa-router')();
const cors = require('koa-cors');
const bodyParser = require('koa-bodyparser');

const { Sequelize, DataTypes } = require('sequelize');
// 方法 3: 分别传递参数 (其它数据库)
const sequelize = new Sequelize('ChinaInfo', 'sa', '123456', {
    host: 'localhost',
    dialect: 'mssql' /* 选择 'mysql' | 'mariadb' | 'postgres' | 'mssql' 其一 */
});

// 定义博客类型模型
let Category = sequelize.define('Category', {
    CateName: {
        type: DataTypes.STRING,
        allowNull: false
    }
})

// 定义博客模型
let Blogs = sequelize.define('Blogs', {
    'Title': {
        type: DataTypes.STRING,
        allowNull: false
    },
    'Content': {
        type: DataTypes.STRING,
        allowNull: false
    },
    CategoryId: {
        type: DataTypes.INTEGER,
        allowNull: false
    }
})

async function init() {
    // 同步模型到数据库
    sequelize.sync({ force: true }).then(async () => {
        let cate = await Category.create({
            CateName: '随笔'
        })
        Blogs.bulkCreate([
            {
                Title: '明天你要上新闻啦',
                Content: '黎妹子的新闻',
                CategoryId: cate.id
            },
            {
                Title: '谢天谢地你来啦',
                Content: '孟叔叔来了',
                CategoryId: cate.id
            },
            {
                Title: '年三十',
                Content: '要过年了',
                CategoryId: cate.id
            },
        ])
    })
}


// init()


const app = new Koa();


router
    // 获取列表数据
    .get('/blogs', async (ctx) => {
        // 获得前端传回的分页参数，pageIndex是指获取第几页的数据，pageSize是指页的记录数
        let pageIndex = parseInt(ctx.request.query.pageIndex);
        let pageSize = parseInt(ctx.request.query.pageSize);

        let cate = await Category.findAll();

        // 使用findAndCountAll函数，直接返回记录和总数量
        let { rows, count } = await Blogs.findAndCountAll({
            offset: (pageIndex - 1) * pageSize,
            limit: pageSize,
            // where:{

            // }
        })

        rows.forEach(item => {
            let tmpCate = cate.find(x => {
                return x.id === item.CategoryId
            })
            if (tmpCate) {
                item.dataValues.CategoryName = tmpCate.CateName
            }
        })
        // 响应，返回给前端的数据
        ctx.body = {
            code: 1000,
            msg: '获取博客列表数据成功',
            data: {
                pageIndex,
                pageSize,
                totalCount: count,
                rows
            }
        }
    })
    // 新增博客
    .post('/blogs', async (ctx) => {
        let obj = ctx.request.body;
        console.log(obj);
        let entity = await Blogs.create(obj);
        ctx.body = {
            code: 1000,
            msg: '新增博客成功',
            data: entity
        }
    })
    // 修改博客
    .put('/blogs/:id', async (ctx) => {
        let id = ctx.request.params.id;
        let obj = ctx.request.body;
        console.log(id);
        console.log(obj);
        let entity = await Blogs.update(obj, {
            where: {
                id: id
            }
        })
        let result = await Blogs.findOne({
            where: {
                id: id
            }
        })
        ctx.body = {
            code: 1000,
            msg: '修改博客成功！',
            data: result
        }
    })
    // 删除博客
    .delete('/blogs/:id', async (ctx) => {
        let id = ctx.request.params.id;
        console.log(id);
        await Blogs.destroy({
            where: {
                id: id
            }
        })
        ctx.body = {
            code: 1000,
            msg: '删除博客成功',
            data: null
        }
    })

// 引入跨域中间件
app.use(cors())
// 引入解析post、put请求时body中的数据中间件
app.use(bodyParser())
// 引入路由中间件
app.use(router.routes())


// 定义端口
let port = 8000;

// 监听请求
app.listen(port)


console.log(`程序运行在如下地址：http://localhost:${port}`);